home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DBOPclient.cpp next >
Text File  |  1996-07-05  |  18KB  |  793 lines
  1. // DBOPclient.cpp
  2. // BOP tcp client
  3. // by D. Gilbert, May 1996
  4.  
  5.  
  6. #include <ncbi.h>
  7. #include <dgg.h>
  8. #include "DList.h"
  9. #include <DControl.h>
  10. #include <DTCP.h>
  11. #include <DWindow.h>
  12. #include <DDialogText.h>
  13. #include <DPanel.h>
  14. #include <DUtil.h>
  15. #include <DChildApp.h>
  16. #include <DTaskCentral.h>
  17. #include <DApplication.h>
  18.  
  19. #include "DBOPclient.h"
  20.  
  21. #define TRIALBOPNOTE
  22.  
  23. const short    kBOPport = 7110;
  24. Local char* gBopHostMarker = "bophost";
  25.  
  26. enum bopperstates {  
  27.     unknown,
  28.     procnew,
  29.     procexec,
  30.     procdone,
  31.     prockill
  32.     };
  33.  
  34.  
  35. class DMsg : public DObject {
  36. public:
  37.     long fNum, fPid, fState;
  38.     char* fName;
  39.     DMsg(): fNum(0), fPid(0), fState(0), fName(NULL) {}
  40.     DMsg( long num, long pid, long state, char* name) : 
  41.         fNum(num), fPid(pid), fState(state)
  42.         { fName= StrDup(name); }
  43.     ~DMsg()  { MemFree(fName); } 
  44. };
  45.  
  46.  
  47.  
  48. // need to call GetDefaults() from some inits.
  49.  
  50. class    DBopSetupDialog : public DWindow
  51. {
  52. public:
  53.     DView *fUsertext, *fPasstext, *fPorttext, *fHosttext, *fSavePass;
  54.     char * fHostname;
  55.     //static char * fgUser, * fgPass;
  56.     static void GetDefaults();
  57.  
  58.     DBopSetupDialog(long id, DTaskMaster* itsSuperior, char* hostname,
  59.         short width = -5, short height = -5, short left = -50, short top = -20, 
  60.         char* title = NULL);
  61.     virtual ~DBopSetupDialog();
  62.     
  63.     virtual DView* InstallUsername(DView* super);
  64.     virtual DView* InstallPassword(DView* super);
  65.     
  66.     virtual void Open(); 
  67.     virtual void         OkayAction();     // override to handle 'OKAY' message
  68.     virtual Boolean IsMyAction(DTaskMaster* action);  
  69.     virtual void SetDlogItems( DView* host, DView* address);
  70.   virtual Nlm_Boolean PoseModally();
  71.     
  72. };
  73.  
  74. //char* DBopSetupDialog::fgUser = NULL;
  75. //char* DBopSetupDialog::fgPass = NULL;
  76.  
  77.  
  78. /*
  79. //usage
  80.             win= new DBopSetupDialog(0, this, hostname, -10, -10, -20, -20, "BOP Logon");
  81.             if (win) win->Open();
  82. */
  83.  
  84.  
  85. // DBOP .............................
  86.  
  87. char* DBOP::gUsername = NULL;
  88. char* DBOP::gPassword = NULL;
  89. char* DBOP::gHost = NULL;
  90. long  DBOP::gPort = kBOPport;
  91.  
  92. DBOP::DBOP()
  93. {
  94.     InitData();
  95. }
  96.  
  97. DBOP::DBOP(char *username, char *password, char *hostname, long port)
  98. {
  99.     InitData();
  100.     ResetHost( username, password, hostname, port);
  101. }
  102.  
  103. void DBOP::InitData()
  104. {
  105.   char  buf[256];
  106.     fHostname = NULL;
  107.     fUsername= NULL;
  108.     fPassword= NULL;
  109.     fMsgCount= 0;
  110.     fPort= kBOPport;
  111.     fState= kClosed;
  112.     fHandshake= NULL;
  113.     fProcessNum= 0;
  114.     fCurrentMsg= 0;
  115.     fDone= 0;
  116.     fMsgList= new DList(); // NULL, DList::kDeleteObjects << doesnt' call destructor!
  117.     sprintf( buf, "DClap-BOP %s", (char*)VersionString());
  118.     fId= StrDup(buf);
  119. }
  120.  
  121. DBOP::~DBOP()
  122. {
  123.     MemFree(fHostname);
  124.     MemFree(fUsername);
  125.     MemFree(fPassword);
  126.     MemFree(fHandshake);
  127.     MemFree(fId);
  128.   if (fMsgList) {
  129.         short i, n = fMsgList->GetSize();
  130.         for (i=0; i<n; i++) {
  131.             DMsg* m= (DMsg*) fMsgList->At(i);
  132.             delete m;
  133.             }
  134.       delete fMsgList;
  135.       }
  136. }
  137.  
  138.  
  139.  
  140. void DBOP::ResetHost(char *username, char *password, char *hostname, long port)
  141. {
  142.     Boolean doreset= false;
  143.     
  144.     if (hostname && (!fHostname || StrCmp(fHostname, hostname)!=0)) {
  145.         MemFree( fHostname);
  146.         if (StrICmp(hostname, gBopHostMarker)==0) 
  147.             fHostname= NULL; // pick it up thru GetLogon()
  148.         else
  149.             fHostname= StrDup( hostname);
  150.         doreset= true;
  151.         }
  152.     if (username && (!fUsername || StrCmp(fUsername, username)!=0)) {
  153.         MemFree( fUsername);
  154.         fUsername= StrDup( username);
  155.         doreset= true;
  156.         }
  157.     if (password && (!fPassword || StrCmp(fPassword, password)!=0)) {
  158.         MemFree( fPassword);
  159.         fPassword= StrDup( password);
  160.         doreset= true;
  161.         }
  162.     if (port && port != fPort) {
  163.         fPort= port;
  164.         doreset= true;
  165.         }
  166.     
  167.     if (doreset) {
  168.         if (fState > kClosed) { Close(); Release(); }
  169.         fState= kClosed;
  170.         }
  171.         
  172.     //Connect(); //??
  173.     if (!fHostname || !*fHostname 
  174.         ||!fUsername || !*fUsername 
  175.         ||!fPassword) GetLogon();
  176. }
  177.  
  178.  
  179.  
  180. Boolean DBOP::WaitHandshake( char OkayCode, Boolean showfail)
  181. {
  182.     MemFree(fHandshake);
  183.     fHandshake= RecvLine(); 
  184.     if (!fHandshake) 
  185.         return false;
  186.     else if (*fHandshake != OkayCode) {
  187.         if (showfail) Fail( fHandshake); 
  188.         if (*fHandshake == '-' && StrStr(fHandshake,"signing off")!=NULL) {
  189.             fState= kClosed;
  190.             Close(); Release();
  191.             }
  192.         return false;
  193.         }
  194.     else {
  195.         if (*fHandshake == '+' && StrStr(fHandshake,"signing off")!=NULL) {
  196.             Close(); Release();
  197.             fState= kClosed;
  198.             }
  199.         return true;
  200.         }
  201. }
  202.  
  203.  
  204. short DBOP::Quit()
  205. {
  206.      if (Status() == kTCPestablished) SendStr("QUIT"CRLF, kDontAddCRLF);
  207.     Close(); Release();
  208.     fState= kClosed;
  209.     return fState;
  210. }
  211.  
  212.  
  213. short DBOP::GetLogon()
  214. {
  215.     Boolean okay= false;
  216.     DBopSetupDialog* win= 
  217.         new DBopSetupDialog(0, NULL, fHostname, -10, -10, -20, -20, "BOP Logon");
  218.     if (win && win->PoseModally()) {
  219.         MemFree(fUsername); fUsername= StrDup( gUsername);  
  220.         MemFree(fPassword); fPassword= StrDup( gPassword); 
  221.         MemFree(fHostname); fHostname= StrDup( gHost); 
  222.         fPort= gPort;
  223.         okay= true;
  224.         }
  225. #ifdef WIN_MAC
  226.   delete win;// already deleted in MSWIN !?  & Unix !!
  227. #endif
  228.     return okay;
  229. }
  230.  
  231.  
  232. short DBOP::Connect()
  233. {
  234.   char    buf[256];
  235.  
  236.     if (Status() == kTCPestablished && CharsAvailable()) {
  237.         // ???
  238.         }
  239.         
  240.      if (Status() != kTCPestablished) {
  241.           // connect to host
  242.       if (fHostname == NULL) return(kClosed); 
  243.         Open(fHostname, fPort);
  244.         if (Failed()) return(kClosed); 
  245.         if (!WaitedForOpen())  return(kClosed);  
  246.         if (!WaitHandshake('+')) return(Quit());
  247.         fState= kConnected;
  248.         }
  249.         
  250.   if (fState < kTransaction) {
  251.           // log on as user
  252.         Boolean retry= true;
  253.         if (!fHostname || !*fHostname || 
  254.             !fUsername || !*fUsername || !fPassword) GetLogon();
  255. logon:
  256.         sprintf( buf, "USER %s"CRLF,fUsername);
  257.         SendStr( buf, kDontAddCRLF);
  258.         if (!WaitHandshake('+'))  return(Quit());
  259.     
  260.         sprintf( buf, "PASS %s"CRLF,fPassword);
  261.         SendStr( buf, kDontAddCRLF);
  262.         if (!WaitHandshake('+')) {
  263.             if (retry && GetLogon()) goto logon;
  264.             return(Quit());
  265.             }
  266.     
  267.                 // get list of existing processes
  268.         SendStr( "LIST"CRLF, kDontAddCRLF);
  269.         if (WaitHandshake('+',false)) {
  270.             long number, pid, state;
  271.             char name[256];
  272.             char* data;
  273.             Boolean done= false;
  274.             while (!done) {
  275.                 data= RecvLine();
  276.               if (data) {    
  277.                   done= (*data == '.');
  278.                   if (!done) {
  279.                       number= pid= state= 0; *name= 0;
  280.                       sscanf(data,"%u %s %u %u", &number, &pid, &state, name);
  281.                       DMsg* msg= new DMsg(number, pid, state, name);
  282.                       fMsgList->InsertLast(msg);
  283.                       fMsgCount++;
  284.                         }
  285.                     MemFree(data);
  286.                     }
  287.                 else done= true;
  288.                 }
  289.             }
  290.  
  291.         fState= kTransaction;
  292.         }
  293.     return(fState); 
  294. }
  295.   
  296.   
  297. short DBOP::CloseMsg()
  298. {
  299.     if (fState == kMsgOpen) {
  300.         SendStr("CLOS"CRLF, kDontAddCRLF);
  301.         if (!WaitHandshake('+')) return(Quit());    
  302.         fState= kTransaction;
  303.         }
  304.     return fState;
  305. }
  306.  
  307.  
  308. short DBOP::CheckStatus( long processNum)
  309. {
  310.     short msgNum= MsgFromProcnum( processNum);
  311.     return CheckMsgStatus( msgNum);
  312. }
  313.  
  314. short DBOP::CheckMsgStatus( short msgNum)
  315. {
  316.   char    buf[256];
  317.  
  318.     fDone= 0; // ?? or save this b/n calls ? - but not same for each msg !
  319.     if (!msgNum) return 0;
  320.     for (short itest=0; itest<2; itest++) {
  321.         if (Connect() < kTransaction) return(fState);
  322.         sprintf( buf, "STAT %d"CRLF, msgNum);
  323.         SendStr( buf, kDontAddCRLF);
  324.         if (WaitHandshake('+')) 
  325.             break; // done with Connect test
  326.         else {
  327.             if (fHandshake == NULL) { 
  328.                 Close(); Release();
  329.                 fState= kClosed; // try to Connect again
  330.                 }
  331.              else {
  332.                  fDone= kProcDone+1; //!?!?! what do we want here
  333.                 return(fDone); // don't quit?
  334.                 }
  335.             }
  336.         }
  337.         
  338.     int num, state = 0;
  339.     *buf= 0;
  340.     sscanf( fHandshake, "+OK %s", buf);
  341.     if (StrNICmp(buf,"done",4)==0) { fDone= kProcDone; fState= kProcDone; }
  342.     
  343.     return(fDone);
  344. }
  345.  
  346.  
  347. short DBOP::OpenMsg( short msgNum)
  348. {
  349.   char    buf[256];
  350.  
  351.     if (!msgNum) return 0;
  352.     if (Connect() < kTransaction) return(fState);
  353.     if (fState == kMsgOpen) 
  354.         if (CloseMsg() != kTransaction) return(Quit());
  355.  
  356.     sprintf( buf, "OPEN %d"CRLF, msgNum);
  357.     SendStr( buf, kDontAddCRLF);
  358.     if (!WaitHandshake('+')) return(fState); // don't quit?
  359.     
  360.     fState= kMsgOpen;
  361.     fCurrentMsg= msgNum;
  362.     return fState;    
  363. }
  364.  
  365.  
  366. short DBOP::CurrentMsg()
  367. {
  368. #if 1
  369.     return fCurrentMsg;  // need this result after Execute() and Quit() !!
  370. #else
  371.       if (fState == kMsgOpen) return fCurrentMsg; 
  372.       else return 0;
  373. #endif
  374. }
  375.  
  376.  
  377. long DBOP::ProcessNum()
  378. {
  379.     return fProcessNum;   
  380. }
  381.  
  382. short DBOP::MsgFromProcnum( long processNum)
  383. {
  384.     if (fMsgList && processNum) {
  385.         short i, n = fMsgList->GetSize();
  386.         for (i=0; i<n; i++) {
  387.             DMsg* msg= (DMsg*) fMsgList->At(i);
  388.             if (msg->fPid == processNum) {
  389.                 return msg->fNum; 
  390.                 }
  391.             }
  392.         }
  393.     return 0;
  394. }
  395.  
  396.  
  397. DMsg* DBOP::MsgFromMsgNum( short msgNum)
  398. {
  399.     DMsg* msg;
  400.     if (fMsgList && msgNum) {
  401.         short i, n = fMsgList->GetSize();
  402.         for (i=0; i<n; i++) {
  403.             msg= (DMsg*) fMsgList->At(i);
  404.             if (msg->fNum == msgNum) return msg; 
  405.             }
  406.         }
  407.     return NULL;
  408. }
  409.  
  410.  
  411. short DBOP::Delete( long processNum)
  412. {
  413.     short msgNum= MsgFromProcnum( processNum);
  414.     return DeleteMsg( msgNum);
  415. }
  416.  
  417. short DBOP::DeleteMsg( short msgNum)
  418. {
  419.     char buf[128];
  420.     
  421.     if (!msgNum) return 0;
  422.     if (Connect() < kTransaction) return(fState);
  423.     if (fState == kMsgOpen && msgNum == fCurrentMsg) CloseMsg();
  424.     sprintf( buf, "DELE %d"CRLF, msgNum);
  425.     SendStr( buf, kDontAddCRLF);
  426.     if (!WaitHandshake('+',false)) ;
  427.     
  428.     DMsg* msg= MsgFromMsgNum( msgNum);
  429.     if (msg) { msg->fPid= 0; msg->fNum= 0; }
  430.     
  431.     return(fState);
  432. }
  433.  
  434.  
  435. short DBOP::GetOutput( long processNum, DList* childFiles)
  436. {
  437.     short msgNum= MsgFromProcnum( processNum);
  438.     return GetMsgOutput( msgNum, childFiles);
  439. }
  440.  
  441. short DBOP::GetMsgOutput( short msgNum, DList* childFiles)
  442. {
  443.   char    buf[512], * name, * mode;
  444.     
  445.     if (!msgNum) return 0;
  446.     if (OpenMsg( msgNum) < kMsgOpen) return(fState);
  447.  
  448.     long n= (childFiles) ? childFiles->GetSize() : 0;
  449.     for (long i=0; i<n; i++) {
  450.         DChildFile * cf= (DChildFile*) childFiles->At(i);
  451.         if (cf && (cf->fKind == DChildFile::kOutput 
  452.         || cf->fKind == DChildFile::kStdout || cf->fKind == DChildFile::kStderr)) {
  453.         
  454.                 // for each output file...
  455.                 // !! use server LIST of files for fine names ??
  456.                 // instead of client file names...
  457.                 // ?? and use LIST & fetch files not on input or output list, after outputs?
  458.  
  459.                     // patch for special file names used by bopper
  460.             Boolean dofreename= false;
  461.             switch (cf->fKind) {
  462.                 case DChildFile::kStdout: name= "stdout"; mode= "a"; break;
  463.                 case DChildFile::kStderr: name= "stderr"; mode= "a"; break;
  464.                 default: 
  465. #if 1
  466.                     name= (char*)cf->GetShortname();  
  467. #else
  468.                     name= StrDup((char*)cf->GetShortname()); // ? problem w/ cf.fName trashing !
  469.                     dofreename= true;
  470. #endif
  471.                     mode= "w"; 
  472.                     break;
  473.                 }
  474.             
  475.             sprintf( buf, "GET %s"CRLF, name);
  476.             SendStr( buf, kDontAddCRLF);
  477.             if (dofreename) { MemFree(name); name=NULL; }
  478.             if (WaitHandshake('+',false)) {
  479.                 ulong datasize, datatotal = 0;
  480.                 Boolean done= false;
  481.                 char * data;
  482.                 short err= cf->Open(mode); // problem here ??
  483.                 do {
  484.                         // only good for ascii data...
  485.                   data= ReadWithChecks( datasize, kTCPStopAtdotcrlf, true);
  486.                   
  487.                       // ReadWithChecks isn't finding stop sign !!
  488.                     data[datasize]= 0;
  489.                     if (datasize==0) done= true;
  490.                     else if (EndOfMessage()) done= true;
  491.                   else if (StrStr( data, LINEEND"."LINEEND) != NULL) done= true;
  492.                   
  493.                   cf->WriteData( data, datasize);
  494.                   datatotal += datasize;
  495.                   MemFree(data);
  496.                 } while (!done);
  497.                 cf->Close();
  498.                 if (!WaitHandshake('+',false)) ;        // flush +OK after file?
  499.                 
  500.                 if (datatotal == 0) {
  501.                     cf->fDelete= true;
  502.                     cf->fAction= DChildFile::kNoAction; // don't try to display null file
  503.                     }
  504.                 }
  505.             }
  506.         }
  507.     
  508.     return(CloseMsg());
  509. }
  510.  
  511.  
  512. short DBOP::Execute( char * cmdline, DList* childFiles)
  513. {
  514.   char    buf[512];
  515.     
  516.     fDone= 0;
  517.     if (Connect() < kTransaction) return(fState);
  518.     if (fState > kTransaction) 
  519.         if (CloseMsg() != kTransaction) return(Quit());
  520.     
  521.           // new command
  522.     SendStr("NEW"CRLF, kDontAddCRLF);
  523.     if (!WaitHandshake('+')) return(Quit());    
  524.     fState= kMsgOpen;
  525.     int msgnum = 0;
  526.     sscanf( fHandshake, "+OK Process %d ", &msgnum);
  527.     fCurrentMsg= msgnum;
  528.  
  529.     sprintf( buf, "CMD %s"CRLF, cmdline);
  530.     SendStr( buf, kDontAddCRLF);
  531.     if (!WaitHandshake('+')) return(Quit());    
  532.  
  533.     long n= (childFiles) ? childFiles->GetSize() : 0;
  534.     for (long i=0; i<n; i++) {
  535.         DChildFile * cf= (DChildFile*) childFiles->At(i);
  536.         if (cf && (cf->fKind == DChildFile::kInput || cf->fKind == DChildFile::kStdin)) {
  537.                 // for each input file...
  538.             sprintf( buf, "PUT %s"CRLF, cf->GetShortname());
  539.             SendStr( buf, kDontAddCRLF);
  540.             if (!WaitHandshake('+')) return(Quit());    
  541.     
  542.             cf->Open("r");
  543.             while (!cf->Eof()) {
  544.                 cf->ReadLine( buf, sizeof(buf)); // buf has NEWLINE !?
  545.                 SendStr(buf, kDontAddCRLF);  
  546.                 }
  547.             cf->Close();
  548.             SendCRLF();     // make sure of final newline ?
  549.             SendStr("."CRLF, kDontAddCRLF);
  550.             if (!WaitHandshake('+')) return(Quit());        
  551.             }
  552.         }
  553.         
  554.         // execute application
  555.     SendStr("EXEC"CRLF, kDontAddCRLF);
  556.     if (!WaitHandshake('+')) return(Quit());        
  557.  
  558.     long pid = 0;
  559.     sscanf( fHandshake, "+OK pid=%u", &pid);
  560.     fProcessNum= pid;
  561.     
  562.     sprintf(buf, "%d", msgnum);
  563.     DMsg* msg= new DMsg( msgnum, pid, procexec, buf);
  564.     fMsgList->InsertLast(msg);
  565.     fMsgCount++;
  566.  
  567. #if 0
  568.         // ! NOTE: current bopper status is returning erroneous "executing" state if no quit
  569.         //   between execute & status call -- fix bopper !        
  570.     return( Quit()); // close up connection to reduce net problems !?
  571. #else        
  572.         // wait a bit for results ??
  573.     return(CloseMsg());
  574. #endif
  575. }  
  576.  
  577.  
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  
  586. // class DBopSetupDialog .............................
  587.  
  588.  
  589. DBopSetupDialog::DBopSetupDialog(long id, DTaskMaster* itsSuperior, char* hostname,
  590.         short width, short height, short left, short top, char* title) :
  591.     DWindow( id, itsSuperior, fixed, width, height, left, top, title, kFreeOnClose)
  592. {
  593.     fUsertext = fPasstext= NULL;
  594.     fHostname= hostname;
  595.     fSavePass= NULL;
  596.     GetDefaults();
  597. }
  598.  
  599. DBopSetupDialog::~DBopSetupDialog() 
  600. {
  601. }
  602.  
  603.  
  604. void DBopSetupDialog::GetDefaults() 
  605. {
  606.     if (!DBOP::gUsername || !DBOP::gPassword|| !DBOP::gHost || !DBOP::gPort) 
  607.     {
  608.         DBOP::gUsername= gApplication->GetPref("Username", "BOPPER", "");
  609.         DBOP::gPassword= gApplication->GetPref("Password", "BOPPER", "");
  610.         DBOP::gHost= gApplication->GetPref("Host", "BOPPER", "");
  611.         DBOP::gPort= gApplication->GetPrefVal("Port", "BOPPER", "7110");
  612.         }
  613. }
  614.  
  615. void DBopSetupDialog::SetDlogItems( DView* username, DView* password) 
  616. {
  617.     fPasstext = password;
  618.     fUsertext = username;
  619. }
  620.  
  621. #if 0
  622. void dapp_ProcessTasks(void)
  623. {
  624.     Nlm_ProcessEventOrIdle();
  625. #ifndef WIN_MSWIN
  626.     Nlm_RemoveDyingWindows();
  627. #endif
  628.     gTaskCentral->NextTask();
  629. }
  630. #endif
  631.  
  632. Nlm_Boolean DBopSetupDialog::PoseModally() 
  633. { 
  634. #if 1
  635.     return DWindow::PoseModally();
  636. #else
  637.     fModal = true;
  638.     this->Open();
  639.     while (fModal)  
  640.         gApplication->ProcessTasks();  //dapp_ProcessTasks();  
  641.     return fOkay; 
  642. #endif
  643. }
  644.  
  645. void DBopSetupDialog::OkayAction() 
  646. {    
  647.     if (fPasstext)    {
  648.         MemFree(DBOP::gPassword); 
  649.         DBOP::gPassword= fPasstext->GetText(); //StrDup(fgPass); 
  650.             // !! MUST ENCRYPT/Decrypt password if storing to file
  651.         if (0 && fSavePass->GetStatus())
  652.              gApplication->SetPref( DBOP::gPassword, "Password", "BOPPER");
  653.         }
  654.     if (fUsertext) {
  655.         MemFree(DBOP::gUsername); 
  656.         DBOP::gUsername= fUsertext->GetText(); //StrDup(fgUser); 
  657.         gApplication->SetPref( DBOP::gUsername, "Username", "BOPPER");
  658.         }
  659.     if (fHosttext) {
  660.         MemFree(DBOP::gHost); 
  661.         DBOP::gHost= fHosttext->GetText();  
  662.         gApplication->SetPref( DBOP::gHost, "Host", "BOPPER");
  663.         }
  664.     if (fPorttext) {
  665.         char* sval= fPorttext->GetText();  
  666.         long val= atol(sval);
  667.         MemFree( sval);
  668.         if (val) {
  669.             DBOP::gPort= val;
  670.             gApplication->SetPref( DBOP::gPort, "Port", "BOPPER");
  671.             }
  672.         }
  673. }
  674.  
  675.  
  676. Boolean DBopSetupDialog::IsMyAction(DTaskMaster* action) 
  677. {    
  678.     return DWindow::IsMyAction(action);    
  679. }
  680.  
  681.  
  682. DView* DBopSetupDialog::InstallUsername(DView* super)
  683. {
  684.     DPrompt* pr= new DPrompt(0, super, "Username:", 0, 0, Nlm_programFont);
  685.     super->NextSubviewToRight();
  686.     
  687.     char* word = (DBOP::gUsername) ? DBOP::gUsername : "";
  688.     DDialogText* ed= new DEditText( 0, super, word, 10);
  689.     this->SetEditText(ed);
  690.     super->NextSubviewBelowLeft();
  691.     return ed;
  692. }
  693.  
  694.  
  695. DView* DBopSetupDialog::InstallPassword(DView* super)
  696. {
  697.     DPrompt* pr= new DPrompt(0, super, "Password:", 0, 0, Nlm_programFont);
  698.     super->NextSubviewToRight();
  699.  
  700.     char* word = (DBOP::gPassword) ? DBOP::gPassword : "";
  701.     DDialogText* ed= new DPasswordText( 0, super, word, 10);
  702.     this->SetEditText(ed);
  703.     super->NextSubviewBelowLeft();
  704.     fSavePass= new DCheckBox(0, super, "Remember password?");
  705.     fSavePass->Disable(); // till we figure out how to encrypt/decrypt passwd
  706.     super->NextSubviewBelowLeft();
  707.     return ed;
  708. }
  709.  
  710. void DBopSetupDialog::Open()
  711. {
  712.     DView *user, *pass;
  713.     char    buf[128];
  714.     
  715.     StrCpy(buf, "BOP logon");
  716.     if (fHostname && *fHostname) { StrCat(buf, " to "); StrCat(buf, fHostname); }
  717.     DPrompt* pr= new DPrompt(0, this, buf, 0, 0, Nlm_programFont);
  718.     this->NextSubviewBelowLeft();
  719.     
  720. #ifdef TRIALBOPNOTE
  721.      {
  722. #ifdef WIN_MAC
  723. #define WRAP_LINE
  724. #else
  725. // need LINEEND's for MSWin's NotePanel !
  726. #define WRAP_LINE   LINEEND
  727. #endif
  728.  
  729.     Nlm_DayTime dt;
  730.     if ( Nlm_GetDayTime( &dt) 
  731.         && dt.tm_year == 96
  732.         && dt.tm_mon < 8 /* sept */
  733.         ) {
  734.             char* title= "Trial BOP services";
  735.             char* desc = 
  736. "For a limited time, you can try BOP services at "WRAP_LINE
  737. "weed.bio.indiana.edu, port 7110.  To log on, use "LINEEND
  738. "   Username: bop"LINEEND
  739. "   Password: seqpup"LINEEND
  740. "If you find this service useful, contact your local "WRAP_LINE
  741. "biocomputing service provider to install a BOP "WRAP_LINE
  742. "server (available from ftp:// iubio.bio.indiana.edu "WRAP_LINE
  743. "/util/dclap/source/.)  This trial service at Indiana "WRAP_LINE
  744. "will end in September 1996.  Access to GCG software "WRAP_LINE
  745. "there after this trial is limited to Indiana U."WRAP_LINE
  746. ;
  747.             DCluster* clu= new DCluster( 0, this, 0, 0, false, title); 
  748.             new DNotePanel(0, clu, desc, 290, 150);    
  749.             this->NextSubviewBelowLeft();
  750.             }
  751.     } 
  752. #endif
  753.  
  754.     user= this->InstallUsername(this);
  755.     pass= this->InstallPassword(this);
  756.     SetDlogItems( user, pass);
  757.     
  758.     if (1) { //!fHostname || !*fHostname)  // ?? do only if fHostname == NULL ??
  759.         char * word, buf[128];
  760.         DView* super= this;
  761.         (void) new DPrompt(0, super, "BOP Host:", 0, 0, Nlm_programFont);
  762.         super->NextSubviewToRight();
  763.         word= (DBOP::gHost) ? DBOP::gHost : "";
  764.         fHosttext= new DEditText( 0, super, word, 15);
  765.         super->NextSubviewBelowLeft();
  766.  
  767.         (void) new DPrompt(0, super, "BOP Port:", 0, 0, Nlm_programFont);
  768.         super->NextSubviewToRight();
  769.         if (!DBOP::gPort) DBOP::gPort= kBOPport;
  770.         sprintf(buf, "%d", DBOP::gPort);
  771.         fPorttext= new DEditText( 0, super, buf, 10);
  772.         super->NextSubviewBelowLeft();
  773.         }
  774.     
  775.     AddOkayCancelButtons();
  776.     DWindow::Open();
  777. }
  778.  
  779.  
  780. void BOPSetLogon()
  781. {
  782.     Boolean okay= false;
  783.     DBopSetupDialog* win= 
  784.         new DBopSetupDialog(0, gApplication, NULL, -10, -10, -20, -20, "BOP Logon");
  785.     if (win && win->PoseModally()) {
  786.         okay= true;
  787.         }
  788. #ifdef WIN_MAC
  789.   delete win;// already deleted in MSWIN !? & UNIX !!
  790. #endif
  791. }
  792.  
  793.